package com.huashi.dealer.core.component;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.huashi.dealer.commonEntity.StoreUser;
import com.huashi.dealer.commonEntity.User;
import com.huashi.dealer.core.util.SaTokenUtil;
import com.huashi.dealer.modular.business.user.mapper.StoreUserMapper;
import com.huashi.dealer.modular.business.user.mapper.UserMapper;
import com.huashi.dealer.modular.business.user.service.UserService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Component
public class DataScopeInfo {
    @Resource
    private UserMapper userMapper;
    @Resource
    private StoreUserMapper storeUserMapper;
    @Resource
    private UserService userService;

    public final Long MANAGERR_ROLE_ID = 10006L;

    public final Long STORE_USER_ROLE_ID = 10007L;

    /**
     * 获取当前用户可查看的用户ID
     * 经销商：只能查看自己的ID
     * 业务员：查看名下所有经销商的ID
     * 业务主管：查看名下所有业务员负责的经销商ID
     *
     * @return 可查看的用户ID列表
     */
    public List<Long> getUserIds() {
        // 获取当前登录用户ID
        Long id = SaTokenUtil.getLoginId();
        if (id == null) {
            return new ArrayList<>();
        }

        // 判断用户类型
        if (SaTokenUtil.isDealer()) {
            // 经销商：只能查看自己的ID
            List<Long> userIds = new ArrayList<>();
            userIds.add(id);
            return userIds;
        } else if (SaTokenUtil.isStoreUser()) {
            // 业务员：获取业务员角色信息
            List<Long> rolelist = userMapper.isManager(id);
            List<StoreUser> storeUser = new ArrayList<>();

            //业务主管
            if (rolelist.contains(MANAGERR_ROLE_ID)) {
                // 获取名下所有业务员负责的经销商
                storeUser = storeUserMapper.selectList(new LambdaQueryWrapper<StoreUser>().eq(StoreUser::getParentId, id));
            } else {
                //业务员
                if (rolelist.contains(STORE_USER_ROLE_ID)) {
                    storeUser.add(storeUserMapper.selectById(id));
                }
            }

            List<User> list = new ArrayList<>();
            //不是业务员和业务主管开放所有数据权限
            if (!rolelist.contains(MANAGERR_ROLE_ID) && !rolelist.contains(STORE_USER_ROLE_ID)) {
                list = userService.list();
            } else {
                List<Long> idList = storeUser.stream().map(StoreUser::getStoreUserId).collect(Collectors.toList());
                // 业务主管还需要获取自己负责的经销商
                if (rolelist.contains(MANAGERR_ROLE_ID)) {
                    idList.add(id); // 将业务主管自己的ID也加入查询条件
                }
                list = userService.list(new LambdaQueryWrapper<User>().in(User::getStoreUserId, idList));
            }
            return list.stream().map(User::getUserId).collect(Collectors.toList());
        } else {
            // 其他情况：可能是管理员，开放所有数据权限
            List<User> list = userService.list();
            return list.stream().map(User::getUserId).collect(Collectors.toList());
        }
    }

    /**
     * 权限查询条件过滤
     * 业务员：返回名下所有经销商的ID列表
     * 业务主管：返回名下所有业务员负责的经销商ID列表
     * 管理员：返回-1（全部有权限）
     *
     * @return ID列表或-1（全部权限）
     */
    public List<Long> filter() {
        List<Long> ids = new ArrayList<>();

        // 获取当前登录用户ID
        Long id = SaTokenUtil.getLoginId();
        if (id == null) {
            return ids;
        }

        if (SaTokenUtil.isStoreUser()) {
            // 业务员：获取业务员角色信息
            List<Long> rolelist = userMapper.isManager(id);
            List<StoreUser> storeUser = new ArrayList<>();

            //业务主管
            if (rolelist.contains(MANAGERR_ROLE_ID)) {
                // 获取名下所有业务员负责的经销商
                storeUser = storeUserMapper.selectList(new LambdaQueryWrapper<StoreUser>().eq(StoreUser::getParentId, id));
            } else {
                //业务员
                if (rolelist.contains(STORE_USER_ROLE_ID)) {
                    storeUser.add(storeUserMapper.selectById(id));
                }
            }

            List<User> list = new ArrayList<>();
            //不是业务员和业务主管开放所有数据权限
            if (!rolelist.contains(MANAGERR_ROLE_ID) && !rolelist.contains(STORE_USER_ROLE_ID)) {
                ids.add(-1L);
                return ids;
            } else {
                List<Long> idList = storeUser.stream().map(StoreUser::getStoreUserId).collect(Collectors.toList());
                // 业务主管还需要获取自己负责的经销商
                if (rolelist.contains(MANAGERR_ROLE_ID)) {
                    idList.add(id); // 将业务主管自己的ID也加入查询条件
                }
                list = userService.list(new LambdaQueryWrapper<User>().in(User::getStoreUserId, idList));
            }
            return list.stream().map(User::getUserId).collect(Collectors.toList());
        } else {
            // 其他情况：可能是管理员，开放所有数据权限
            ids.add(-1L);
            return ids;
        }
    }

    /**
     * 判定当前用户身份类型
     *
     * @return 身份类型标识
     * -1: 经销商
     * 1: 业务员
     * 2: 业务主管
     * 3: 管理员（非业务员和业务主管）
     * 9: 未知身份
     */
    public int identity() {
        // 获取当前登录用户ID
        Long id = SaTokenUtil.getLoginId();
        if (id == null) {
            return 9; // 未登录或未知身份
        }

        // 先判断用户类型
        if (SaTokenUtil.isDealer()) {
            // 经销商
            return -1;
        } else if (SaTokenUtil.isStoreUser()) {
            // 业务员：需要进一步判断是普通业务员还是业务主管
            List<Long> rolelist = userMapper.isManager(id);
            if (rolelist.isEmpty()) {
                return 9; // 未知身份
            }

            //业务主管 2
            if (rolelist.contains(MANAGERR_ROLE_ID)) {
                return 2;
            }
            //业务员 1
            if (rolelist.contains(STORE_USER_ROLE_ID)) {
                return 1;
            }
            //不是业务员和业务主管开放所有数据权限  3
            if (!rolelist.contains(MANAGERR_ROLE_ID) && !rolelist.contains(STORE_USER_ROLE_ID)) {
                return 3;
            }

            return 9; // 未知身份
        } else {
            // 其他情况：可能是管理员
            return 3;
        }
    }

    /**
     * 获取当前用户身份描述
     *
     * @return 身份描述字符串
     */
    public String getIdentityDescription() {
        int identity = identity();
        switch (identity) {
            case -1:
                return "经销商";
            case 1:
                return "业务员";
            case 2:
                return "业务主管";
            case 3:
                return "管理员";
            default:
                return "未知身份";
        }
    }

    /**
     * 判断当前用户是否为经销商
     *
     * @return true为经销商
     */
    public boolean isCurrentUserDealer() {
        return identity() == -1;
    }

    /**
     * 判断当前用户是否为业务员
     *
     * @return true为业务员
     */
    public boolean isCurrentUserStoreUser() {
        return identity() == 1;
    }

    /**
     * 判断当前用户是否为业务主管
     *
     * @return true为业务主管
     */
    public boolean isCurrentUserManager() {
        return identity() == 2;
    }

    /**
     * 判断当前用户是否为管理员
     *
     * @return true为管理员
     */
    public boolean isCurrentUserAdmin() {
        return identity() == 3;
    }

    /**
     * 获取当前登录的后台用户ID
     *
     * @return 后台用户ID，如果是经销商则返回null
     */
    public Long getCurrentStoreUserId() {
        // 获取当前登录用户ID
        Long id = SaTokenUtil.getLoginId();
        if (id == null) {
            return null;
        }

        // 只有后台用户（业务员、业务主管、管理员）才有store_user_id
        if (SaTokenUtil.isStoreUser()) {
            return id;
        }

        return null;
    }
}